package com.zhj.interview;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;

/**
 * @author zhj
 */
public class Test19 {
    public static void main(String[] args) throws Exception {
        // 1.带返回值的异步任务(不指定线程池，默认ForkJoinPool.commonPool()，单核ThreadPerTaskExecutor)
        CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {
            return 1 + 1;
        });
        System.out.println("cf1 result: " + cf1.get());
        // 2.无返回值的异步任务(不指定线程池，默认ForkJoinPool.commonPool()，单核ThreadPerTaskExecutor)
        CompletableFuture cf2 = CompletableFuture.runAsync(() -> {
            int a = 1 + 1;
        });
        System.out.println("cf2 result: " + cf2.get());
        // 3.指定线程池的带返回值的异步任务，runAsync同理
        CompletableFuture<Integer> cf3 = CompletableFuture.supplyAsync(() -> {
            return 1 + 1;
        }, Executors.newCachedThreadPool());
        System.out.println("cf3 result: " + cf3.get());
        // 4.回调，任务执行完成后执行的动作
        CompletableFuture<Integer> cf4 = cf1.thenApply((result) -> {
            System.out.println("cf4回调拿到cf1的结果 result : " + result);
            return result + 1;
        });
        System.out.println("cf4 result: " + cf4.get());
        // 5.异步回调(将回调任务提交到线程池)，任务执行完成后执行的动作后异步执行
        CompletableFuture<Integer> cf5 = cf1.thenApplyAsync((result) -> {
            System.out.println("cf5回调拿到cf1的结果 result : " + result);
            return result + 1;
        });
        System.out.println("cf5 result: " + cf5.get());
        // 6.回调(同thenApply但无返回结果)，任务执行完成后执行的动作
        CompletableFuture cf6 = cf1.thenAccept((result) -> {
            System.out.println("cf6回调拿到cf1的结果 result : " + result);
        });
        System.out.println("cf6 result: " + cf6.get());
        // 7.回调(同thenAccept但无入参)，任务执行完成后执行的动作
        CompletableFuture cf7 = cf1.thenRun(() -> {
        });
        System.out.println("cf7 result: " + cf7.get());
        // 8.异常回调，任务执行出现异常后执行的动作
        CompletableFuture<Integer> cf = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("出现异常");
        });
        CompletableFuture<Integer> cf8 = cf.exceptionally((result) -> {
            return -1;
        });
        System.out.println("cf8 result: " + cf8.get());
        // 9.当某个任务执行完成后执行的回调方法，会将执行结果或者执行期间抛出的异常传递给回调方法
        //   如果是正常执行则异常为null，回调方法对应的CompletableFuture的result和该任务一致;
        //   如果该任务正常执行，则get方法返回执行结果，如果是执行异常，则get方法抛出异常。
        CompletableFuture<Integer> cf9 = cf1.handle((a, b) -> {
            if (b != null) {
                b.printStackTrace();
            }
            return a;
        });
        System.out.println("cf9 result: " + cf9.get());
        // 10 与handle类似，无返回值
        try {
            CompletableFuture<Integer> cf10 = cf.whenComplete((a, b) -> {
                if (b != null) {
                    b.printStackTrace();
                }
            });
            System.out.println("cf10 result: " + cf10.get());
        } catch (Exception e) {
            System.out.println("cf10 出现异常！！！");
        }
        // 11 组合处理(两个都完成，然后执行)有入参，有返回值
        CompletableFuture<Integer> cf11 = cf1.thenCombine(cf3, (r1, r2) -> {
            return r1 + r2;
        });
        System.out.println("cf11 result: " + cf11.get());
        // 12 组合处理(两个都完成，然后执行)有入参，无返回值
        CompletableFuture cf12 = cf1.thenAcceptBoth(cf3, (r1, r2) -> {
        });
        System.out.println("cf12 result: " + cf12.get());
        // 13 组合处理(两个都完成，然后执行)无入参，无返回值
        CompletableFuture cf13 = cf1.runAfterBoth(cf3, () -> {
        });
        System.out.println("cf13 result: " + cf13.get());
        // 14 组合处理(有一个完成，然后执行)有入参，有返回值
        CompletableFuture<Integer> cf14 = cf1.applyToEither(cf3, (r) -> {
            return r;
        });
        System.out.println("cf14 result: " + cf14.get());
        // 15 组合处理(有一个完成，然后执行)有入参，无返回值
        CompletableFuture cf15 = cf1.acceptEither(cf3, (r) -> {
        });
        System.out.println("cf15 result: " + cf15.get());
        // 16 组合处理(有一个完成，然后执行)无入参，无返回值
        CompletableFuture cf16 = cf1.runAfterEither(cf3, () -> {
        });
        System.out.println("cf16 result: " + cf16.get());
        // 17 方法执行后返回一个新的CompletableFuture
        CompletableFuture<Integer> cf17 = cf1.thenCompose((r) -> {
            return CompletableFuture.supplyAsync(() -> {
                return 1 + 1;
            });
        });
        System.out.println("cf17 result: " + cf17.get());
        // 18 多个任务都执行成功才会继续执行
        CompletableFuture.allOf(cf1,cf2,cf3).whenComplete((r, t) -> {
            System.out.println(r);
        });
        // 18 多个任务任意一个执行成功就会继续执行
        CompletableFuture.anyOf(cf1,cf2,cf3).whenComplete((r, t) -> {
            System.out.println(r);
        });
    }
}
